package com.ics.atable.chat.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.ics.atable.chat.expection.BusinessException;
import com.ics.atable.chat.expection.ErrorCode;
import com.ics.atable.chat.mapper.DataCellWideMapper;
import com.ics.atable.chat.model.dto.SqlReplaceDTO;
import com.ics.atable.chat.model.entity.DataCellWide;
import com.ics.atable.chat.service.AiExplanationService;
import com.ics.atable.chat.service.SqlQueryService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

/**
 * SQL 查询服务实现类
 *
 * @author system
 */
@Service
@Slf4j
@DS("slave") // 使用 slave 数据源（atable-user）
public class SqlQueryServiceImpl implements SqlQueryService {

    @Autowired
    private DataCellWideMapper dataCellWideMapper;

    @Autowired
    private AiExplanationService aiExplanationService;

    // 写死的 SQL 模板（作为案例）
    private static final String SQL_TEMPLATE = 
            "SELECT full_item_name, full_column_name, table_year, task_quarter, full_org_name, cell_value " +
            "FROM t_data_cell_wide " +
            "WHERE full_item_name = '蔬菜（不含食用菌）/叶菜类/菠菜' " +
            "AND full_column_name = '本季/产量/上年' " +
            "AND table_year = 2025 " +
            "AND task_quarter = 2 " +
            "AND full_org_name LIKE '%贵州省/贵阳市/云岩区%'";

    @Override
    public SqlReplaceDTO.QueryResponse queryData(SqlReplaceDTO.QueryRequest.ReplaceParams replaceParams) {
        // 验证参数
        validateQueryParams(replaceParams);

        try {
            // 1. 使用 JSON 参数替换 SQL 模板中的值
            String replacedSql = replaceSqlTemplate(replaceParams);
            log.info("替换后的 SQL: {}", replacedSql);

            // 2. 执行替换后的 SQL 查询
            // 处理地名：提取最后一级地名用于模糊匹配
            String orgNameForQuery = extractLastLevelOrgName(replaceParams.getFullOrgName());
            log.info("原始地名: {}, 用于查询的地名: {}", replaceParams.getFullOrgName(), orgNameForQuery);
            
            List<DataCellWide> results = dataCellWideMapper.queryByConditions(
                    replaceParams.getFullItemName(),
                    replaceParams.getFullColumnName(),
                    replaceParams.getTableYear(),
                    replaceParams.getTaskQuarter(),
                    orgNameForQuery
            );

            // 3. 限制返回前5条数据
            List<DataCellWide> limitedResults = results.stream()
                    .limit(5)
                    .collect(Collectors.toList());
            
            log.info("查询到 {} 条记录，返回前 {} 条", results.size(), limitedResults.size());

            // 4. 转换结果
            SqlReplaceDTO.QueryResponse response = new SqlReplaceDTO.QueryResponse();
            response.setResults(convertToResultList(limitedResults));
            response.setCount(limitedResults.size());

            // 5. 使用 AI 生成自然语言解释（基于前5条数据）
            String explanation = aiExplanationService.generateExplanation(replaceParams, limitedResults);
            response.setExplanation(explanation);

            log.info("查询成功，返回 {} 条记录", limitedResults.size());
            return response;

        } catch (Exception e) {
            log.error("数据库查询失败", e);
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "数据库查询失败: " + e.getMessage());
        }
    }

    /**
     * 使用 JSON 参数替换 SQL 模板中的值
     *
     * @param replaceParams 替换参数
     * @return 替换后的 SQL 语句
     */
    private String replaceSqlTemplate(SqlReplaceDTO.QueryRequest.ReplaceParams replaceParams) {
        String sql = SQL_TEMPLATE;

        // 替换 full_item_name
        sql = sql.replaceFirst(
                "full_item_name = '[^']*'",
                "full_item_name = '" + replaceParams.getFullItemName() + "'"
        );

        // 替换 full_column_name
        sql = sql.replaceFirst(
                "full_column_name = '[^']*'",
                "full_column_name = '" + replaceParams.getFullColumnName() + "'"
        );

        // 替换 table_year
        sql = sql.replaceFirst(
                "table_year = \\d+",
                "table_year = " + replaceParams.getTableYear()
        );

        // 替换 task_quarter
        sql = sql.replaceFirst(
                "task_quarter = \\d+",
                "task_quarter = " + replaceParams.getTaskQuarter()
        );

        // 替换 full_org_name（使用 LIKE 匹配）
        sql = sql.replaceFirst(
                "full_org_name LIKE '%[^%]*%'",
                "full_org_name LIKE '%" + replaceParams.getFullOrgName() + "%'"
        );

        return sql;
    }

    @Override
    public void validateQueryParams(SqlReplaceDTO.QueryRequest.ReplaceParams replaceParams) {
        if (replaceParams == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "查询参数不能为空");
        }

        if (StringUtils.isBlank(replaceParams.getFullItemName())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "指标全量名称不能为空");
        }

        if (StringUtils.isBlank(replaceParams.getFullColumnName())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "填报列全量名称不能为空");
        }

        if (StringUtils.isBlank(replaceParams.getTableYear())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "年份不能为空");
        }

        if (StringUtils.isBlank(replaceParams.getTaskQuarter())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "季度不能为空");
        }

        if (StringUtils.isBlank(replaceParams.getFullOrgName())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "区划名不能为空");
        }
    }

    /**
     * 提取地名的最后一级用于模糊匹配
     * 例如："贵州省/贵阳市/息烽县/永靖镇/洪马村" -> "洪马村"
     * 这样可以匹配到"上洪马村"、"下洪马村"等
     *
     * @param fullOrgName 完整地名
     * @return 最后一级地名
     */
    private String extractLastLevelOrgName(String fullOrgName) {
        if (StringUtils.isBlank(fullOrgName)) {
            return fullOrgName;
        }
        
        // 如果包含 '/'，提取最后一级
        if (fullOrgName.contains("/")) {
            String[] parts = fullOrgName.split("/");
            return parts[parts.length - 1];
        }
        
        return fullOrgName;
    }

    /**
     * 将实体列表转换为结果列表
     *
     * @param entities 实体列表
     * @return 结果列表
     */
    private List<SqlReplaceDTO.QueryResponse.DataCellWideResult> convertToResultList(List<DataCellWide> entities) {
        return entities.stream()
                .map(this::convertToResult)
                .collect(Collectors.toList());
    }

    /**
     * 将实体转换为结果对象
     *
     * @param entity 实体对象
     * @return 结果对象
     */
    private SqlReplaceDTO.QueryResponse.DataCellWideResult convertToResult(DataCellWide entity) {
        SqlReplaceDTO.QueryResponse.DataCellWideResult result = new SqlReplaceDTO.QueryResponse.DataCellWideResult();
        result.setFullItemName(entity.getFullItemName());
        result.setFullColumnName(entity.getFullColumnName());
        result.setTableYear(entity.getTableYear());
        result.setTaskQuarter(entity.getTaskQuarter());
        result.setFullOrgName(entity.getFullOrgName());
        
        // 处理 cellValue 为空的情况，并拼接单位
        String cellValue = entity.getCellValue();
        String unit = determineUnit(entity.getFullColumnName());
        
        if (StringUtils.isBlank(cellValue)) {
            // cellValue 为空时，返回"暂无数据"
            result.setCellValue("暂无数据");
        } else if (StringUtils.isNotBlank(unit)) {
            // cellValue 不为空且有单位时，拼接单位
            result.setCellValue(cellValue + unit);
        } else {
            // cellValue 不为空但没有单位时，直接返回原值
            result.setCellValue(cellValue);
        }
        
        return result;
    }

    /**
     * 根据列名判断数值单位
     *
     * @param fullColumnName 填报列全量名称
     * @return 单位字符串
     */
    private String determineUnit(String fullColumnName) {
        if (StringUtils.isBlank(fullColumnName)) {
            return "";
        }
        
        String columnName = fullColumnName.toLowerCase();
        
        // 判断是否为面积相关
        if (columnName.contains("面积")) {
            return "亩";
        }
        
        // 判断是否为产量相关
        if (columnName.contains("产量")) {
            return "吨";
        }
        
        // 默认返回空字符串
        return "";
    }

    @Override
    public SqlReplaceDTO.QueryResponse batchQueryData(SqlReplaceDTO.BatchQueryRequest.BatchReplaceParams batchParams) {
        // 验证参数
        validateBatchQueryParams(batchParams);

        try {
            // 1. 提取每个地名的最后一级用于模糊匹配
            List<String> orgNamesForQuery = batchParams.getFullOrgNames().stream()
                    .map(this::extractLastLevelOrgName)
                    .collect(Collectors.toList());
            
            log.info("原始地名列表: {}, 用于查询的地名列表: {}", batchParams.getFullOrgNames(), orgNamesForQuery);

            // 2. 执行批量查询
            List<DataCellWide> results = dataCellWideMapper.queryByMultipleOrgNames(
                    batchParams.getFullItemName(),
                    batchParams.getFullColumnName(),
                    batchParams.getTableYear(),
                    batchParams.getTaskQuarter(),
                    orgNamesForQuery
            );
            
            log.info("批量查询到 {} 条记录", results.size());

            // 3. 转换结果（不限制条数）
            SqlReplaceDTO.QueryResponse response = new SqlReplaceDTO.QueryResponse();
            response.setResults(convertToResultList(results));
            response.setCount(results.size());

            // 4. 使用 AI 生成自然语言解释（基于所有数据）
            // 创建临时的 ReplaceParams 用于 AI 解释
            SqlReplaceDTO.QueryRequest.ReplaceParams tempParams = new SqlReplaceDTO.QueryRequest.ReplaceParams();
            tempParams.setFullItemName(batchParams.getFullItemName());
            tempParams.setFullColumnName(batchParams.getFullColumnName());
            tempParams.setTableYear(batchParams.getTableYear());
            tempParams.setTaskQuarter(batchParams.getTaskQuarter());
            tempParams.setFullOrgName(String.join(", ", batchParams.getFullOrgNames()));
            
            String explanation = aiExplanationService.generateExplanation(tempParams, results);
            response.setExplanation(explanation);

            log.info("批量查询成功，返回 {} 条记录", results.size());
            return response;

        } catch (Exception e) {
            log.error("批量数据库查询失败", e);
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "批量数据库查询失败: " + e.getMessage());
        }
    }

    /**
     * 验证批量查询参数
     *
     * @param batchParams 批量查询参数
     */
    private void validateBatchQueryParams(SqlReplaceDTO.BatchQueryRequest.BatchReplaceParams batchParams) {
        if (batchParams == null) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "查询参数不能为空");
        }

        if (StringUtils.isBlank(batchParams.getFullItemName())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "指标全量名称不能为空");
        }

        if (StringUtils.isBlank(batchParams.getFullColumnName())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "填报列全量名称不能为空");
        }

        if (StringUtils.isBlank(batchParams.getTableYear())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "年份不能为空");
        }

        if (StringUtils.isBlank(batchParams.getTaskQuarter())) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "季度不能为空");
        }

        if (batchParams.getFullOrgNames() == null || batchParams.getFullOrgNames().isEmpty()) {
            throw new BusinessException(ErrorCode.PARAMS_ERROR, "区划名列表不能为空");
        }
    }

}
